声明 模块 "assert" {

    //@@{ 内部:internal, 错误_:Error }
    函数 内部(值: 任意, 消息?: 文字 | 错误_): 无值;

    //@@{ 内部:internal }
    名域 内部 {

        //@@{ 断言错误_:AssertionError, 错误_:Error }
        类别 断言错误_ 实现 错误_ {

            //@@{ 名称:name }
            名称: 文字;

            //@@{ 消息:message }
            消息: 文字;

            //@@{ 实际:actual }
            实际: 任意;

            //@@{ 预期:expected }
            预期: 任意;

            //@@{ 操作符:operator }
            操作符: 文字;

            //@@{ 生成消息:generatedMessage }
            生成消息: 真假;

            //@@{ 代码:code, "__错误_断言__":"ERR_ASSERTION" }
            代码: '__错误_断言__';

            构造(选项组?: {

                //@@{ 消息:message, 实际:actual, 预期:expected }
                消息?: 文字; 实际?: 任意; 预期?: 任意;

                //@@{ 操作符:operator, 堆栈启动FN:stackStartFn, 函数_:Function }
                操作符?: 文字; 堆栈启动FN?: 函数_
            });
        }

        //@@{ 失败:fail, 错误_:Error }
        函数 失败(消息?: 文字 | 错误_): 不及;
        /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */

        //@@{ 失败:fail, 错误_:Error, 函数_:Function }
        函数 失败(实际: 任意, 预期: 任意, 消息?: 文字 | 错误_, 操作符?: 文字, 堆栈启动FN?: 函数_): 不及;

        //@@{ 正确:ok, 错误_:Error }
        函数 正确(值: 任意, 消息?: 文字 | 错误_): 无值;
        /** @deprecated since v9.9.0 - use strictEqual() instead. */

        //@@{ 等于:equal, 错误_:Error }
        函数 等于(实际: 任意, 预期: 任意, 消息?: 文字 | 错误_): 无值;
        /** @deprecated since v9.9.0 - use notStrictEqual() instead. */

        //@@{ 不等:notEqual, 错误_:Error }
        函数 不等(实际: 任意, 预期: 任意, 消息?: 文字 | 错误_): 无值;
        /** @deprecated since v9.9.0 - use deepStrictEqual() instead. */

        //@@{ 深度等于:deepEqual, 错误_:Error }
        函数 深度等于(实际: 任意, 预期: 任意, 消息?: 文字 | 错误_): 无值;
        /** @deprecated since v9.9.0 - use notDeepStrictEqual() instead. */

        //@@{ 不深度等于:notDeepEqual, 错误_:Error }
        函数 不深度等于(实际: 任意, 预期: 任意, 消息?: 文字 | 错误_): 无值;

        //@@{ 严格相等:strictEqual, 错误_:Error }
        函数 严格相等(实际: 任意, 预期: 任意, 消息?: 文字 | 错误_): 无值;

        //@@{ 不严格相等:notStrictEqual, 错误_:Error }
        函数 不严格相等(实际: 任意, 预期: 任意, 消息?: 文字 | 错误_): 无值;

        //@@{ 深度严格相等:deepStrictEqual, 错误_:Error }
        函数 深度严格相等(实际: 任意, 预期: 任意, 消息?: 文字 | 错误_): 无值;

        //@@{ 不深度严格相等:notDeepStrictEqual, 错误_:Error }
        函数 不深度严格相等(实际: 任意, 预期: 任意, 消息?: 文字 | 错误_): 无值;

        //@@{ 抛出的:throws, 错误_:Error }
        函数 抛出的(块: () => 任意, 消息?: 文字 | 错误_): 无值;

        //@@{ 抛出的:throws, 正则_:RegExp, 函数_:Function, 实例_:Object, 错误_:Error }
        函数 抛出的(块: () => 任意, 错误: 正则_ | 函数_ | 实例_ | 错误_, 消息?: 文字 | 错误_): 无值;

        //@@{ 不抛出:doesNotThrow, 错误_:Error }
        函数 不抛出(块: () => 任意, 消息?: 文字 | 错误_): 无值;

        //@@{ 不抛出:doesNotThrow, 正则_:RegExp, 函数_:Function, 错误_:Error }
        函数 不抛出(块: () => 任意, 错误: 正则_ | 函数_, 消息?: 文字 | 错误_): 无值;

        //@@{ 如果错误:ifError }
        函数 如果错误(值: 任意): 无值;

        //@@{ 拒绝:rejects, 预设_:Promise, 错误_:Error }
        函数 拒绝(块: (() => 预设_<任意>) | 预设_<任意>, 消息?: 文字 | 错误_): 预设_<无值>;

        //@@{ 拒绝:rejects, 预设_:Promise, 正则_:RegExp, 函数_:Function, 实例_:Object, 错误_:Error }
        函数 拒绝(块: (() => 预设_<任意>) | 预设_<任意>, 错误: 正则_ | 函数_ | 实例_ | 错误_, 消息?: 文字 | 错误_): 预设_<无值>;

        //@@{ 不拒绝:doesNotReject, 预设_:Promise, 错误_:Error }
        函数 不拒绝(块: (() => 预设_<任意>) | 预设_<任意>, 消息?: 文字 | 错误_): 预设_<无值>;

        //@@{ 不拒绝:doesNotReject, 预设_:Promise, 正则_:RegExp, 函数_:Function, 错误_:Error }
        函数 不拒绝(块: (() => 预设_<任意>) | 预设_<任意>, 错误: 正则_ | 函数_, 消息?: 文字 | 错误_): 预设_<无值>;

        //@@{ 严格的:strict, 内部:internal }
        常量 严格的: 类为 内部;
    }

    //@@{ 内部:internal }
    导出 = 内部;
}
